package com.bjpowernode.sparsearray;

import java.io.*;
import java.util.ArrayList;

/**
 * @author wuyuecai
 * @create 2021-06-01 12:48
 */
public class SparseArray {
    /*
二维数组 转 稀疏数组的思路
1. 遍历原始的二维数组，得到有效数据的个数 sum
2. 根据sum 就可以创建 稀疏数组 sparseArr   int[sum + 1] [3]
3. 将二维数组的有效数据数据存入到 稀疏数组

稀疏数组转原始的二维数组的思路

1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的  chessArr2 = int [11][11]
2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.

 */
    public static void main(String[] args) throws Exception {
        //二维数组转稀疏数组 用1表示黑子，用2表示蓝子，用0表示无数据
        int[][] chessArr1 = new int[5][5];//创建一个二维数组
        chessArr1[2][1] = 1;
        chessArr1[3][2] = 2;
        chessArr1[4][2] = 1;
        //1.遍历原始数组获取有效数据的个数
        int sum = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if(chessArr1[i][j] != 0){
                    sum += 1;
                }
            }
        }
        //2.根据sum创建稀疏数组
        int counter = 0;//用于记录稀疏数组的行数
        int[][] sparseArr1 = new int[sum+1][3];
        sparseArr1[counter][0] = chessArr1.length;
        sparseArr1[counter][1] = chessArr1[0].length;
        sparseArr1[counter][2] = sum;
        //3.将原始数组中的有效数据存入稀疏数组中
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if(chessArr1[i][j] != 0){
                    sparseArr1[++counter][0] = i;
                    sparseArr1[counter][1] = j;
                    sparseArr1[counter][2] = chessArr1[i][j];

                }
            }
        }

        //将稀疏数组存储到磁盘中.txt文件，使用objectouputstream，对象输出流存储数组中的每一个数据
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("map"));
        os.writeObject(sparseArr1);
        os.close();

        //从磁盘中读取稀疏数组，稀疏数组转为原始数组
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("map"));
        //从磁盘中读取数据，并进行强制类型转换
        int[][] sparseArr2 = (int[][]) ois.readObject();
        ois.close();

        //1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int[][] chessArr2 = new int[sparseArr2[0][0]][sparseArr2[0][1]];
        //2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组即可.
        for (int i = 1; i < sparseArr2.length; i++) {
            int m = sparseArr1[i][0];
            int n = sparseArr1[i][1];
            chessArr2[m][n] = sparseArr1[i][2];
        }


//        输出原始数组
        System.out.println("原始数组");
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                System.out.print(chessArr1[i][j]+"\t");
            }
            System.out.println();
        }

//        输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < sparseArr1.length; i++) {
            for (int j = 0; j < sparseArr1[i].length; j++) {
                System.out.print(sparseArr1[i][j]+"\t");
            }
            System.out.println();
        }

        System.out.println();

//        输出还原之后的原始数组
        System.out.println("还原之后的原始数组");
        for (int i = 0; i < chessArr2.length; i++) {
            for (int j = 0; j < chessArr2[i].length; j++) {
                System.out.print(chessArr2[i][j]+"\t");
            }
            System.out.println();
        }

    }
}

